src/core/view.ts (5)

39-43: SIGINT listener is never removed and could leak in tests.

process.on('SIGINT', ...) registers a permanent listener. If execute is ever called more than once (e.g., in a test harness), listeners accumulate. Consider using process.once('SIGINT', ...) or storing the handler and calling process.removeListener alongside clearInterval.

Proposed fix

-      process.on('SIGINT', () => {
+      const onSigint = () => {
         clearInterval(interval);
         console.log('\nExiting watch mode...');
         process.exit(0);
-      });
+      };
+      process.once('SIGINT', onSigint);

---

46-46: await new Promise(() => {}) blocks forever — intentional but fragile.

This is the standard "keep-alive" pattern for CLI watch loops, but it means execute() never returns in watch mode. The only exit path is process.exit(0) inside the SIGINT handler. This makes unit-testing watch mode very difficult (no way to programmatically stop it). Consider accepting an AbortSignal or returning the interval handle for testability.

---

214-215: totalChanges is computed but never used.

This variable is dead code. Remove it or wire it into the summary output.

Proposed fix

-    const totalChanges =
-      changesData.draft.length + changesData.active.length + changesData.completed.length;

---

228-231: No-op forEach on completed changes.

This loop body is empty. Either remove it or implement the intended logic (e.g., accumulating task counts from completed changes into totalTasks/completedTasks).

Proposed fix — remove the no-op loop

-    changesData.completed.forEach(() => {
-      // Completed changes count as 100% done (we don't know exact task count)
-      // This is a simplification
-    });

---

53-121: Inconsistent output assembly: append vs direct output +=.

Lines 118–119 concatenate directly to output (skipping append), so they don't get the trailing \n that append adds. Meanwhile, getSummaryOutput (Line 65) is also concatenated directly. The mixing is easy to misread and could introduce subtle double-newline or missing-newline issues during future edits. Consider using append consistently, or document the intent.

test/core/view.test.ts (1)

9-128: No tests cover watch mode.

The watch mode path (options.watch = true) is untestable with the current design since execute never returns. Consider adding a note/TODO, or refactoring execute to accept an AbortSignal so watch mode can be stopped programmatically in tests.

src/core/view.ts (3)

39-39: Async callback in setInterval can cause overlapping executions.

setInterval(update, 2000) fires every 2 s regardless of whether the previous update() (which is async) has finished. If getDashboardOutput ever takes longer than 2 s (e.g., large project, slow disk), two invocations will race and interleave process.stdout.write calls, producing garbled output.

A simple fix is to use a recursive setTimeout instead:

Proposed fix

-      const interval = setInterval(update, 2000);
+      let timeout: ReturnType<typeof setTimeout>;
+      const scheduleNext = () => {
+        timeout = setTimeout(async () => {
+          await update();
+          scheduleNext();
+        }, 2000);
+      };
+      scheduleNext();

Adjust cleanup references from clearInterval(interval) to clearTimeout(timeout) accordingly.

---

60-69: Never-resolving promise on Line 68 keeps the function from ever returning.

When no AbortSignal is provided, await new Promise(() => {}) hangs forever — the only escape is process.exit(0) inside the SIGINT handler. This is acceptable for CLI entry points but makes the method impossible to use programmatically or in integration tests without an AbortSignal.

Consider documenting this contract explicitly (e.g., a JSDoc note that callers must pass signal if they need the function to return), or provide a fallback that resolves when SIGINT fires instead of calling process.exit:

Sketch

      } else {
-        await new Promise(() => {});
+        await new Promise<void>((resolve) => {
+          const onSigint = () => {
+            clearInterval(interval);
+            console.log('\nExiting watch mode...');
+            resolve();
+          };
+          process.once('SIGINT', onSigint);
+        });
       }

This would unify the exit path and let the function return cleanly without process.exit.

---

41-47: process.exit(0) in cleanup is a hard exit that bypasses any callers awaiting execute.

When SIGINT fires (without an AbortSignal), the cleanup handler calls process.exit(0), which immediately terminates the process. Any finally blocks or post-execute logic in the caller will never run. This is related to the never-resolving promise on Line 68 — if the promise were made resolvable on SIGINT (as suggested above), the process.exit here becomes unnecessary and cleanup becomes more composable.